﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using Demo.Mmose.Common.Util;

namespace Demo.Mmose.Common.Atom
{
    public class AtomicUshort : IAtomOperator<ushort>, IComparable, IComparable<AtomicUshort>
    {
        #region zh-CHS 构造和初始化和清理 | en Constructors and Initializers and Dispose
        /// <summary>
        /// 
        /// </summary>
        private AtomicUshort()
        {
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="atomicUshort"></param>
        private AtomicUshort( ushort atomicUshort )
        {
            m_AtomicUshort = atomicUshort;
        }
        #endregion

        #region zh-CHS 属性 | en Properties
        #region zh-CHS 私有成员变量 | en Private Member Variables
        /// <summary>
        /// 
        /// </summary>
        private int m_AtomicUshort = 0;
        #endregion
        /// <summary>
        /// 
        /// </summary>
        public ushort Value
        {
            get { return (ushort)m_AtomicUshort; }
        }
        #endregion

        #region zh-CHS 接口实现 | en Interface Implementation
        /// <summary>
        /// 以原子方式将给定值与当前值相加。
        /// </summary>
        /// <param name="addValue"></param>
        /// <returns></returns>
        public void Add( ushort addValue )
        {
            Interlocked.Add( ref m_AtomicUshort, addValue );
        }

        /// <summary>
        /// 以原子方式将给定值与当前值相减。
        /// </summary>
        /// <param name="subtractValue"></param>
        /// <returns></returns>
        public void Subtract( ushort subtractValue )
        {
            Interlocked.Add( ref m_AtomicUshort, - subtractValue );
        }

        /// <summary>
        /// 以原子方式将给定值与当前值相乘。
        /// </summary>
        /// <param name="multiplyValue"></param>
        /// <returns></returns>
        public void Multiply( ushort multiplyValue )
        {
            int oldAtomicUshort;
            int newAtomicUshort;

            do
            {
                oldAtomicUshort = (ushort)m_AtomicUshort;
                newAtomicUshort = (ushort)m_AtomicUshort * multiplyValue;

            } while ( Interlocked.CompareExchange( ref m_AtomicUshort, newAtomicUshort, oldAtomicUshort ) != oldAtomicUshort );
        }

        /// <summary>
        /// 以原子方式将给定值与当前值相除。
        /// </summary>
        /// <param name="divideValue"></param>
        /// <returns></returns>
        public void Divide( ushort divideValue )
        {
            int oldAtomicUshort;
            int newAtomicUshort;

            do
            {
                oldAtomicUshort = (ushort)m_AtomicUshort;
                newAtomicUshort = (ushort)m_AtomicUshort / divideValue;

            } while ( Interlocked.CompareExchange( ref m_AtomicUshort, newAtomicUshort, oldAtomicUshort ) != oldAtomicUshort );
        }

        /// <summary>
        /// 以原子方式设置为给定值。
        /// </summary>
        /// <param name="assignmentValue"></param>
        /// <returns></returns>
        public void Assignment( ushort assignmentValue )
        {
            int oldAtomicUshort;
            int newAtomicUshort;

            do
            {
                oldAtomicUshort = (ushort)m_AtomicUshort;
                newAtomicUshort = assignmentValue;

            } while ( Interlocked.CompareExchange( ref m_AtomicUshort, newAtomicUshort, oldAtomicUshort ) != oldAtomicUshort );
        }

        /// <summary>
        /// 如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值。
        /// </summary>
        /// <param name="setValue"></param>
        /// <param name="compareValue"></param>
        /// <returns></returns>
        public bool CompareExchange( ushort setValue, ushort compareValue )
        {
            return Interlocked.CompareExchange( ref m_AtomicUshort, setValue, compareValue ) == compareValue;
        }

        /// <summary>
        /// 以原子方式将当前值减 1 ( -- )
        /// </summary>
        /// <returns></returns>
        public void Decrement()
        {
            Interlocked.Decrement( ref m_AtomicUshort );
        }

        /// <summary>
        /// 以原子方式将当前值加 1 ( ++ )
        /// </summary>
        /// <returns></returns>
        public void Increment()
        {
            Interlocked.Increment( ref m_AtomicUshort );
        }

        /// <summary>
        /// 以原子方式将当前值左移 ( << )
        /// </summary>
        /// <returns></returns>
        public void LeftShift( int leftShift )
        {
            int oldAtomicUshort;
            int newAtomicUshort;

            do
            {
                oldAtomicUshort = (ushort)m_AtomicUshort;
                newAtomicUshort = (ushort)m_AtomicUshort << leftShift;

            } while ( Interlocked.CompareExchange( ref m_AtomicUshort, newAtomicUshort, oldAtomicUshort ) != oldAtomicUshort );
        }

        /// <summary>
        /// 以原子方式将当前值右移 ( >> )
        /// </summary>
        /// <returns></returns>
        public void RightShift( int rightShift )
        {
            int oldAtomicUshort;
            int newAtomicUshort;

            do
            {
                oldAtomicUshort = (ushort)m_AtomicUshort;
                newAtomicUshort = (ushort)m_AtomicUshort >> rightShift;

            } while ( Interlocked.CompareExchange( ref m_AtomicUshort, newAtomicUshort, oldAtomicUshort ) != oldAtomicUshort );
        }

        /// <summary>
        /// 以原子方式将当前值求正(一元操作) ( + )
        /// </summary>
        /// <param name="addValue"></param>
        /// <returns></returns>
        public void Plus()
        {
            // 不用执行，本来就是正值
        }

        /// <summary>
        /// 以原子方式将当前值求负(一元操作) ( - )
        /// </summary>
        /// <param name="addValue"></param>
        /// <returns></returns>
        public void Minus()
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 以原子方式将当前值取反(一元操作) ( ! )
        /// </summary>
        /// <param name="addValue"></param>
        /// <returns></returns>
        public void Invert()
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 以原子方式将当前值求补 ( ~ )
        /// </summary>
        /// <returns></returns>
        public void OneComplement()
        {
            int oldAtomicUshort;
            int newAtomicUshort;

            do
            {
                oldAtomicUshort = (ushort)m_AtomicUshort;
                newAtomicUshort = ~(ushort)m_AtomicUshort;

            } while ( Interlocked.CompareExchange( ref m_AtomicUshort, newAtomicUshort, oldAtomicUshort ) != oldAtomicUshort );
        }

        /// <summary>
        /// 以原子方式将当前值按位与 ( &= )
        /// </summary>
        /// <returns></returns>
        public void BitwiseAND( ushort bitwiseAnd )
        {
            int oldAtomicUshort;
            int newAtomicUshort;

            do
            {
                oldAtomicUshort = (ushort)m_AtomicUshort;
                newAtomicUshort = (ushort)m_AtomicUshort & bitwiseAnd;

            } while ( Interlocked.CompareExchange( ref m_AtomicUshort, newAtomicUshort, oldAtomicUshort ) != oldAtomicUshort );
        }

        /// <summary>
        /// 以原子方式将当前值按位或 ( |= )
        /// </summary>
        /// <returns></returns>
        public void BitwiseInclusiveOR( ushort inclusiveOR )
        {
            int oldAtomicUshort;
            int newAtomicUshort;

            do
            {
                oldAtomicUshort = (ushort)m_AtomicUshort;
                newAtomicUshort = (ushort)m_AtomicUshort | inclusiveOR;

            } while ( Interlocked.CompareExchange( ref m_AtomicUshort, newAtomicUshort, oldAtomicUshort ) != oldAtomicUshort );
        }

        /// <summary>
        /// 以原子方式将当前值按位异或 ( ^= )
        /// </summary>
        /// <returns></returns>
        public void BitwiseExclusiveOR( ushort exclusiveOR )
        {
            int oldAtomicUshort;
            int newAtomicUshort;

            do
            {
                oldAtomicUshort = (ushort)m_AtomicUshort;
                newAtomicUshort = (ushort)m_AtomicUshort ^ exclusiveOR;

            } while ( Interlocked.CompareExchange( ref m_AtomicUshort, newAtomicUshort, oldAtomicUshort ) != oldAtomicUshort );
        }
        #endregion

        #region zh-CHS 共有委托 | en Public Delegate
        #region zh-CHS 私有成员变量 | en Private Member Variables
        /// <summary>
        /// 
        /// </summary>
        private EventHandler<UpdatingValue<ushort>> m_EventUpdatingValue;
        /// <summary>
        /// 
        /// </summary>
        private SpinLock m_LockEventUpdating = new SpinLock();
        #endregion
        /// <summary>
        /// 
        /// </summary>
        public event EventHandler<UpdatingValue<ushort>> UpdatingValue
        {
            add
            {
                SpinLockEx.ReliableEnter( ref m_LockEventUpdating );
                {
                    m_EventUpdatingValue += value;
                }
                m_LockEventUpdating.Exit();
            }
            remove
            {
                SpinLockEx.ReliableEnter( ref m_LockEventUpdating );
                {
                    m_EventUpdatingValue -= value;
                }
                m_LockEventUpdating.Exit();
            }
        }

        #region zh-CHS 私有成员变量 | en Private Member Variables
        /// <summary>
        /// 
        /// </summary>
        private EventHandler<UpdatedValue<ushort>> m_EventUpdatedValue;
        /// <summary>
        /// 
        /// </summary>
        private SpinLock m_LockEventUpdated = new SpinLock();
        #endregion
        /// <summary>
        /// 
        /// </summary>
        public event EventHandler<UpdatedValue<ushort>> UpdatedValue
        {
            add
            {
                SpinLockEx.ReliableEnter( ref m_LockEventUpdated );
                {
                    m_EventUpdatedValue += value;
                }
                m_LockEventUpdated.Exit();
            }
            remove
            {
                SpinLockEx.ReliableEnter( ref m_LockEventUpdated );
                {
                    m_EventUpdatedValue -= value;
                }
                m_LockEventUpdated.Exit();
            }
        }
        #endregion

        #region zh-CHS 方法 | en Method
        /// <summary>
        /// 将当前值左移 ( << )，并返回左移后的数据
        /// </summary>
        /// <param name="atomicUshortA"></param>
        /// <param name="atomicUshortB"></param>
        /// <returns></returns>
        public static AtomicUshort operator >>( AtomicUshort atomicUshortA, int atomicUshortB )
        {
            return new AtomicUshort( (ushort)( (ushort)atomicUshortA.m_AtomicUshort >> atomicUshortB ) );
        }

        /// <summary>
        /// 将当前值右移 ( >> )，并返回右移后的数据
        /// </summary>
        /// <param name="atomicUshortA"></param>
        /// <param name="atomicUshortB"></param>
        /// <returns></returns>
        public static AtomicUshort operator <<( AtomicUshort atomicUshortA, int atomicUshortB )
        {
            return new AtomicUshort( (ushort)( (ushort)atomicUshortA.m_AtomicUshort << atomicUshortB ) );
        }

        /// <summary>
        /// 将给定值与当前值相加，并返回相加后的数据
        /// </summary>
        /// <param name="atomicUshortA"></param>
        /// <param name="atomicUshortB"></param>
        /// <returns></returns>
        public static AtomicUshort operator +( AtomicUshort atomicUshortA, ushort atomicUshortB )
        {
            return new AtomicUshort( (ushort)( (ushort)atomicUshortA.m_AtomicUshort + atomicUshortB ) );
        }

        /// <summary>
        /// 将给定值与当前值相加，并返回相加后的数据
        /// </summary>
        /// <param name="atomicUshortA"></param>
        /// <param name="atomicUshortB"></param>
        /// <returns></returns>
        public static AtomicUshort operator +( AtomicUshort atomicUshortA, AtomicUshort atomicUshortB )
        {
            return new AtomicUshort( (ushort)( (ushort)atomicUshortA.m_AtomicUshort + (ushort)atomicUshortB.m_AtomicUshort ) );
        }

        /// <summary>
        /// 将给定值与当前值相减，并返回相减后的数据
        /// </summary>
        /// <param name="atomicUshortA"></param>
        /// <param name="atomicUshortB"></param>
        /// <returns></returns>
        public static AtomicUshort operator -( AtomicUshort atomicUshortA, ushort atomicUshortB )
        {
            return new AtomicUshort( (ushort)( (ushort)atomicUshortA.m_AtomicUshort - atomicUshortB ) );
        }

        /// <summary>
        /// 将给定值与当前值相减，并返回相减后的数据
        /// </summary>
        /// <param name="atomicUshortA"></param>
        /// <param name="atomicUshortB"></param>
        /// <returns></returns>
        public static AtomicUshort operator -( AtomicUshort atomicUshortA, AtomicUshort atomicUshortB )
        {
            return new AtomicUshort( (ushort)( (ushort)atomicUshortA.m_AtomicUshort - (ushort)atomicUshortB.m_AtomicUshort ) );
        }

        /// <summary>
        /// 将给定值与当前值相乘，并返回相乘后的数据
        /// </summary>
        /// <param name="atomicUshortA"></param>
        /// <param name="atomicUshortB"></param>
        /// <returns></returns>
        public static AtomicUshort operator *( AtomicUshort atomicUshortA, ushort atomicUshortB )
        {
            return new AtomicUshort( (ushort)( (ushort)atomicUshortA.m_AtomicUshort * atomicUshortB ) );
        }

        /// <summary>
        /// 将给定值与当前值相乘，并返回相乘后的数据
        /// </summary>
        /// <param name="atomicUshortA"></param>
        /// <param name="atomicUshortB"></param>
        /// <returns></returns>
        public static AtomicUshort operator *( AtomicUshort atomicUshortA, AtomicUshort atomicUshortB )
        {
            return new AtomicUshort( (ushort)( (ushort)atomicUshortA.m_AtomicUshort * (ushort)atomicUshortB.m_AtomicUshort ) );
        }

        /// <summary>
        /// 将当前值与给定值相除，并返回相除后的数据
        /// </summary>
        /// <param name="atomicUshortA"></param>
        /// <param name="atomicUshortB"></param>
        /// <returns></returns>
        public static AtomicUshort operator /( AtomicUshort atomicUshortA, ushort atomicUshortB )
        {
            return new AtomicUshort( (ushort)( (ushort)atomicUshortA.m_AtomicUshort / atomicUshortB ) );
        }

        /// <summary>
        /// 将当前值与给定值相除，并返回相除后的数据
        /// </summary>
        /// <param name="atomicUshortA"></param>
        /// <param name="atomicUshortB"></param>
        /// <returns></returns>
        public static AtomicUshort operator /( AtomicUshort atomicUshortA, AtomicUshort atomicUshortB )
        {
            return new AtomicUshort( (ushort)( (ushort)atomicUshortA.m_AtomicUshort / (ushort)atomicUshortB.m_AtomicUshort ) );
        }

        /// <summary>
        /// 将当前值与给定值相模，并返回相模后的数据
        /// </summary>
        /// <param name="atomicUshortA"></param>
        /// <param name="atomicUshortB"></param>
        /// <returns></returns>
        public static AtomicUshort operator %( AtomicUshort atomicUshortA, ushort atomicUshortB )
        {
            return new AtomicUshort( (ushort)( (ushort)atomicUshortA.m_AtomicUshort % atomicUshortB ) );
        }

        /// <summary>
        /// 将当前值与给定值相模，并返回相模后的数据
        /// </summary>
        /// <param name="atomicUshortA"></param>
        /// <param name="atomicUshortB"></param>
        /// <returns></returns>
        public static AtomicUshort operator %( AtomicUshort atomicUshortA, AtomicUshort atomicUshortB )
        {
            return new AtomicUshort( (ushort)( (ushort)atomicUshortA.m_AtomicUshort % (ushort)atomicUshortB.m_AtomicUshort ) );
        }

        /// <summary>
        /// 将当前值与给定值相与，并返回相与后的数据
        /// </summary>
        /// <param name="atomicUshortA"></param>
        /// <param name="atomicUshortB"></param>
        /// <returns></returns>
        public static AtomicUshort operator &( AtomicUshort atomicUshortA, ushort atomicUshortB )
        {
            return new AtomicUshort( (ushort)( (ushort)atomicUshortA.m_AtomicUshort & atomicUshortB ) );
        }

        /// <summary>
        /// 将当前值与给定值相与，并返回相与后的数据
        /// </summary>
        /// <param name="atomicUshortA"></param>
        /// <param name="atomicUshortB"></param>
        /// <returns></returns>
        public static AtomicUshort operator &( AtomicUshort atomicUshortA, AtomicUshort atomicUshortB )
        {
            return new AtomicUshort( (ushort)( (ushort)atomicUshortA.m_AtomicUshort & (ushort)atomicUshortB.m_AtomicUshort ) );
        }

        /// <summary>
        /// 将当前值与给定值相或，并返回相或后的数据
        /// </summary>
        /// <param name="atomicUshortA"></param>
        /// <param name="atomicUshortB"></param>
        /// <returns></returns>
        public static AtomicUshort operator |( AtomicUshort atomicUshortA, ushort atomicUshortB )
        {
            return new AtomicUshort( (ushort)( (ushort)atomicUshortA.m_AtomicUshort | atomicUshortB ) );
        }

        /// <summary>
        /// 将当前值与给定值相或，并返回相或后的数据
        /// </summary>
        /// <param name="atomicUshortA"></param>
        /// <param name="atomicUshortB"></param>
        /// <returns></returns>
        public static AtomicUshort operator |( AtomicUshort atomicUshortA, AtomicUshort atomicUshortB )
        {
            return new AtomicUshort( (ushort)( (ushort)atomicUshortA.m_AtomicUshort | (ushort)atomicUshortB.m_AtomicUshort ) );
        }

        /// <summary>
        /// 将当前值与给定值相异或，并返回相异或后的数据
        /// </summary>
        /// <param name="atomicUshortA"></param>
        /// <param name="atomicUshortB"></param>
        /// <returns></returns>
        public static AtomicUshort operator ^( AtomicUshort atomicUshortA, ushort atomicUshortB )
        {
            return new AtomicUshort( (ushort)( (ushort)atomicUshortA.m_AtomicUshort ^ atomicUshortB ) );
        }

        /// <summary>
        /// 将当前值与给定值相异或，并返回相异或后的数据
        /// </summary>
        /// <param name="atomicUshortA"></param>
        /// <param name="atomicUshortB"></param>
        /// <returns></returns>
        public static AtomicUshort operator ^( AtomicUshort atomicUshortA, AtomicUshort atomicUshortB )
        {
            return new AtomicUshort( (ushort)( (ushort)atomicUshortA.m_AtomicUshort ^ (ushort)atomicUshortB.m_AtomicUshort ) );
        }

        /// <summary>
        /// 将当前值求补，并返回求补后的数据
        /// </summary>
        /// <param name="atomicUshortA"></param>
        /// <returns></returns>
        public static AtomicUshort operator ~( AtomicUshort atomicUshort )
        {
            return new AtomicUshort( (ushort)~(ushort)atomicUshort.m_AtomicUshort );
        }

        /// <summary>
        /// 以原子方式将当前值加 1 ( ++ )
        /// </summary>
        /// <param name="l"></param>
        /// <param name="r"></param>
        /// <returns></returns>
        public static AtomicUshort operator ++( AtomicUshort atomicUshort )
        {
            atomicUshort.Increment();

            return atomicUshort;
        }

        /// <summary>
        /// 以原子方式将当前值减 1 ( -- )
        /// </summary>
        /// <param name="l"></param>
        /// <param name="r"></param>
        /// <returns></returns>
        public static AtomicUshort operator --( AtomicUshort atomicUshort )
        {
            atomicUshort.Decrement();

            return atomicUshort;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="l"></param>
        /// <param name="r"></param>
        /// <returns></returns>
        public static bool operator ==( AtomicUshort atomicUshortA, AtomicUshort atomicUshortB )
        {
            return (ushort)atomicUshortA.m_AtomicUshort == (ushort)atomicUshortB.m_AtomicUshort;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="l"></param>
        /// <param name="r"></param>
        /// <returns></returns>
        public static bool operator ==( AtomicUshort atomicUshortA, ushort atomicUshortB )
        {
            return (ushort)atomicUshortA.m_AtomicUshort == atomicUshortB;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="l"></param>
        /// <param name="r"></param>
        /// <returns></returns>
        public static bool operator !=( AtomicUshort atomicUshortA, AtomicUshort atomicUshortB )
        {
            return (ushort)atomicUshortA.m_AtomicUshort != (ushort)atomicUshortB.m_AtomicUshort;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="l"></param>
        /// <param name="r"></param>
        /// <returns></returns>
        public static bool operator !=( AtomicUshort atomicUshortA, ushort atomicUshortB )
        {
            return (ushort)atomicUshortA.m_AtomicUshort != atomicUshortB;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="l"></param>
        /// <param name="r"></param>
        /// <returns></returns>
        public static bool operator <( AtomicUshort atomicUshortA, AtomicUshort atomicUshortB )
        {
            return (ushort)atomicUshortA.m_AtomicUshort < (ushort)atomicUshortB.m_AtomicUshort;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="l"></param>
        /// <param name="r"></param>
        /// <returns></returns>
        public static bool operator <( AtomicUshort atomicUshortA, ushort atomicUshortB )
        {
            return (ushort)atomicUshortA.m_AtomicUshort < atomicUshortB;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="l"></param>
        /// <param name="r"></param>
        /// <returns></returns>
        public static bool operator >( AtomicUshort atomicUshortA, AtomicUshort atomicUshortB )
        {
            return (ushort)atomicUshortA.m_AtomicUshort > (ushort)atomicUshortB.m_AtomicUshort;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="l"></param>
        /// <param name="r"></param>
        /// <returns></returns>
        public static bool operator >( AtomicUshort atomicUshortA, ushort atomicUshortB )
        {
            return (ushort)atomicUshortA.m_AtomicUshort > atomicUshortB;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="l"></param>
        /// <param name="r"></param>
        /// <returns></returns>
        public static bool operator <=( AtomicUshort atomicUshortA, AtomicUshort atomicUshortB )
        {
            return (ushort)atomicUshortA.m_AtomicUshort <= (ushort)atomicUshortB.m_AtomicUshort;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="l"></param>
        /// <param name="r"></param>
        /// <returns></returns>
        public static bool operator <=( AtomicUshort atomicUshortA, ushort atomicUshortB )
        {
            return (ushort)atomicUshortA.m_AtomicUshort <= atomicUshortB;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="l"></param>
        /// <param name="r"></param>
        /// <returns></returns>
        public static bool operator >=( AtomicUshort atomicUshortA, AtomicUshort atomicUshortB )
        {
            return (ushort)atomicUshortA.m_AtomicUshort >= (ushort)atomicUshortB.m_AtomicUshort;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="l"></param>
        /// <param name="r"></param>
        /// <returns></returns>
        public static bool operator >=( AtomicUshort atomicUshortA, ushort atomicUshortB )
        {
            return (ushort)atomicUshortA.m_AtomicUshort >= atomicUshortB;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="iSerial"></param>
        /// <returns></returns>
        public static explicit operator ushort( AtomicUshort atomicUshort )
        {
            return (ushort)atomicUshort.m_AtomicUshort;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="atomicUshort"></param>
        /// <returns></returns>
        public static implicit operator AtomicUshort( ushort atomicUshort )
        {
            return new AtomicUshort( atomicUshort );
        }
        #endregion

        #region zh-CHS 方法覆盖 | en Method Overrides
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return m_AtomicUshort.ToString();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public override int GetHashCode()
        {
            return m_AtomicUshort.GetHashCode();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="xObject"></param>
        /// <returns></returns>
        public override bool Equals( object xObject )
        {
            AtomicUshort atomicUshort = xObject as AtomicUshort;
            if ( atomicUshort == null )
                return false;

            return (ushort)atomicUshort.m_AtomicUshort == (ushort)m_AtomicUshort;
        }
        #endregion

        #region zh-CHS 接口实现 | en Interface Implementation
        /// <summary>
        /// 
        /// </summary>
        /// <param name="otherAtomicInt"></param>
        /// <returns></returns>
        public int CompareTo( AtomicUshort otherAtomicInt )
        {
            return ( (ushort)m_AtomicUshort ).CompareTo( (ushort)otherAtomicInt.m_AtomicUshort );
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="otherObject"></param>
        /// <returns></returns>
        public int CompareTo( object otherObject )
        {
            AtomicUshort atomicUshort = otherObject as AtomicUshort;
            if ( atomicUshort == null )
                return 1;
            else
                return CompareTo( atomicUshort );
        }
        #endregion
    }
}
